Runtime Verification in Context : Can Optimizing Error Detection Improve Fault Diagnosis

Runtime verification has primarily been developed and evaluated as a means of enriching the software testing process. While many researchers have pointed to its potential applicability in online approaches to software fault tolerance, there has been a dearth of work exploring the details of how that might be accomplished. In this paper, we describe how a component-oriented approach to software health management exposes the connections between program execution, error detection, fault diagnosis, and recovery. We identify both research challenges and opportunities in exploiting those connections. Specifically, we describe how recent approaches to reducing the overhead of runtime monitoring aimed at error detection might be adapted to reduce the overhead and improve the effectiveness of fault diagnosis

CGuard: Efficient Spatial Safety for C

Spatial safety violations are the root cause of many security attacks and unexpected behavior of applications. Existing techniques to enforce spatial safety work broadly at either object or pointer granularity. Object-based approaches tend to incur high CPU overheads, whereas pointer-based approaches incur both high CPU and memory overheads. SGXBounds, an object-based approach, is so far the most efficient technique that provides complete out-of-bounds protection for objects. However, a major drawback of this approach is that it can't support address space larger than 32-bit. In this paper, we present CGuard, a tool that provides object-bounds protection for C applications with comparable overheads to SGXBounds without restricting the application address space. CGuard stores the bounds information just before the base address of an object and encodes the relative offset of the base address in the spare bits of the virtual address available in x86_64 architecture. For an object that can't fit in the spare bits, CGuard uses a custom memory layout that enables it to find the base address of the object in just one memory access. Our study revealed spatial safety violations in the gcc and x264 benchmarks from the SPEC CPU2017 benchmark suite and the string_match benchmark from the Phoenix benchmark suite. The execution time overheads for the SPEC CPU2017 and Phoenix benchmark suites were 42% and 26% respectively, whereas the reduction in the throughput for the Apache webserver when the CPUs were fully saturated was 30%. These results indicate that CGuard can be highly effective while maintaining a reasonable degree of efficiency

REVERT: A Monitor Generation Tool for Real-Time Systems

IEEE Real-Time Systems Symposium (RTSS 2016). 29, Nov to 2, Dec, 2016, RTSS@Work. Porto, Portugal.We present REVERT (which stands for RuntimE VErification for Real-Time systems), a new tool to generate monitors for real-time systems. REVERT takes specifications written in a new Domain Specific Language (DSL) and automatically generates monitors under the form of complete timed deterministic finite automata (DFA). The generated timed DFA can later be used to generate code that can eventually be integrated within the monitored system.info:eu-repo/semantics/publishedVersio

Including Everyone, Everywhere:Understanding Opportunities and Challenges of Geographic Gender-Inclusion in OSS

The gender gap is a significant concern facing the software industry as the development becomes more geographically distributed. Widely shared reports indicate that gender differences may be specific to each region. However, how complete can these reports be with little to no research reflective of the Open Source Software (OSS) process and communities software is now commonly developed in? Our study presents a multi-region geographical analysis of gender inclusion on GitHub. This mixed-methods approach includes quantitatively investigating differences in gender inclusion in projects across geographic regions and investigate these trends over time using data from contributions to 21,456 project repositories. We also qualitatively understand the unique experiences of developers contributing to these projects through a survey that is strategically targeted to developers in various regions worldwide. Our findings indicate that gender diversity is low across all parts of the world, with no substantial difference across regions. However, there has been statistically significant improvement in diversity worldwide since 2014, with certain regions such as Africa improving at faster pace. We also find that most motivations and barriers to contributions (e.g., lack of resources to contribute and poor working environment) were shared across regions, however, some insightful differences, such as how to make projects more inclusive, did arise. From these findings, we derive and present implications for tools that can foster inclusion in open source software communities and empower contributions from everyone, everywhere

Exploiting Program and Property Structure for Efficient Runtime Monitoring

Modern software systems are complex and often built using components that are provided with their application programming interface (API) to assist a user. However, this API is informal and if used incorrectly, may lead to bugs that are hard to detect. In order to address the problem of API conformance checking, researchers have proposed various analysis techniques including static and dynamic typestate analysis. However, it is extremely challenging to develop a static analysis that is both precise and scalable. On the other hand, dynamic analysis or runtime monitoring of programs may incur heavy overhead, thereby limiting its application only to a subset of realistic programs. This heavy overhead could be a result of handling of the monitors that are created during runtime, or the events generated by program instrumentation, or some other factors related to program and property interaction. Our research focuses on developing techniques that optimize program instrumentation to reduce the monitoring overhead without compromising error reporting. The techniques are guided by the cost models that we have developed for runtime monitoring and based on a hybrid approach that combines static with dynamic typestate analysis to exploit the benefits of both approaches. In addition, the approach also leverages the property structure to make monitor optimization more effective. In this dissertation, we present cost models for runtime monitoring that are based on our understanding of the existing monitoring tools. The cost models describe key factors that influence the monitoring overhead as well as the relationship among them. We develop two novel analysis techniques, namely the residual analysis and the stutter-equivalent loop transformation, that target the number of events as that is a primary factor associated with the total cost of monitoring. We present the results of their evaluation based on some open source applications and benchmarks that show that the techniques can effectively reduce the monitoring overhead. Adviser: Matthew B. Dwye